home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: delta / whiteline CD Series - delta.iso / tools / utils / smc_tt1 / wd_tools.c < prev    next >
C/C++ Source or Header  |  1995-11-25  |  22KB  |  611 lines
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <tos.h>
  4.  
  5. void debug_str(char *str);
  6.  
  7. void pfcopy(unsigned char* dest,unsigned char* src,short anz);
  8.  
  9. #include "..\include\lan.h"
  10. #include "..\include\wd.h"
  11. #include "..\include\driver.h"
  12. #include "..\include\fifo.h"
  13.  
  14. adapter_typ ds;         /* Speicher fuer Adapterparameter         */
  15.  
  16. extern PROTOCOL protos[MAXPROTOCOLS];  /* protocols to serve */
  17. extern int protocols ;              /* number of active protocols */
  18. extern ff_typ ff_free;                        /* queue of free packets */
  19. extern et_stat statistics;                   /* Statistik             */
  20.  
  21. unsigned char *wd_reg00,*wd_reg01,*wd_reg02,*wd_reg03,*wd_reg04,*wd_reg05,*wd_reg06,*wd_reg07;
  22. unsigned char *wd_reg08,*wd_reg09,*wd_reg0a,*wd_reg0b,*wd_reg0c,*wd_reg0d,*wd_reg0e,*wd_reg0f;
  23. unsigned char *wd_reg10,*wd_reg11,*wd_reg12,*wd_reg13,*wd_reg14,*wd_reg15,*wd_reg16,*wd_reg17;
  24. unsigned char *wd_reg18,*wd_reg19,*wd_reg1a,*wd_reg1b,*wd_reg1c,*wd_reg1d,*wd_reg1e,*wd_reg1f;
  25.  
  26. #define REG_MSR  (*wd_reg00)
  27. #define REG_ICR  (*wd_reg01)        /* interface configuration register */
  28. #define REG_IAR  (*wd_reg02)        /* io address register */
  29. #define REG_BIO  (*wd_reg03)        /* bios ROM address register */
  30. #define REG_IRR  (*wd_reg04)        /* interrupt request register */
  31. #define REG_GP1  (*wd_reg05)        /* general purpose register 1 */
  32. #define REG_IOD  (*wd_reg06)        /* io data latch */
  33. #define REG_GP2  (*wd_reg07)        /* general purpose register 2 */
  34.  
  35. #define REG_REG_0 (*wd_reg00)
  36. #define REG_REG_1 (*wd_reg01)
  37. #define REG_REG_2 (*wd_reg02)
  38. #define REG_REG_3 (*wd_reg03)
  39. #define REG_REG_4 (*wd_reg04)
  40. #define REG_REG_5 (*wd_reg05)
  41. #define REG_REG_6 (*wd_reg06)
  42. #define REG_REG_7 (*wd_reg07)
  43.  
  44. #define REG_LAN_ADDR_0 (*wd_reg08)
  45. #define REG_LAN_ADDR_1 (*wd_reg09)
  46. #define REG_LAN_ADDR_2 (*wd_reg0a)
  47. #define REG_LAN_ADDR_3 (*wd_reg0b)
  48. #define REG_LAN_ADDR_4 (*wd_reg0c)
  49. #define REG_LAN_ADDR_5 (*wd_reg0d)
  50. #define REG_LAN_TYPE_BYTE (*wd_reg0e)
  51. #define REG_CHCKSM_BYTE (*wd_reg0f)
  52.  
  53. #define REG_CR     (*wd_reg10)        /* Command Register    */
  54. #define REG_CLDA0  (*wd_reg11)        /* Current Local DMA Address 0 */
  55. #define REG_CLDA1  (*wd_reg12)        /* Current Local DMA Address 1 */
  56. #define REG_BNRY   (*wd_reg13)        /* Boundary Pointer */
  57. #define REG_TSR    (*wd_reg14)        /* Transmit Status Register */
  58. #define REG_NCR    (*wd_reg15)        /* Number of Collisions Register */
  59. #define REG_FIFO   (*wd_reg16)        /* FIFO */
  60. #define REG_ISR    (*wd_reg17)        /* Interrupt Status Register */
  61. #define REG_CRDA0  (*wd_reg18)        /* Current Remote DMA Address 0 */
  62. #define REG_CRDA1  (*wd_reg19)        /* Current Remote DMA Address 1 */
  63. /* OFF_8390+0x0A is reserved */
  64. /* OFF_8390+0x0B is reserved */
  65. #define REG_RSR    (*wd_reg1c)        /* Receive Status Register */
  66. #define REG_CNTR0  (*wd_reg1d)        /* Frame Alignment Errors */
  67. #define REG_CNTR1  (*wd_reg1e)        /* CRC Errors */
  68. #define REG_CNTR2  (*wd_reg1f)        /* Missed Packet Errors */
  69.  
  70. /*-- page 0, wr --*/
  71. /*    CR    OFF_8390+0x00           Command Register    */
  72. #define REG_PSTART (*wd_reg11)        /* Page Start Register */
  73. #define REG_PSTOP  (*wd_reg12)        /* Page Stop Register */
  74. /*    BNDY    OFF_8390+0x03           Boundary Pointer    */
  75. #define REG_TPSR   (*wd_reg14)        /* Transmit Page Start Register */
  76. #define REG_TBCR0  (*wd_reg15)        /* Transmit Byte Count Register 0*/
  77. #define REG_TBCR1  (*wd_reg16)        /* Transmit Byte Count Register 1*/
  78. /*    ISR    OFF_8390+0x07           Interrupt Status Register    */
  79. #define REG_RSAR0  (*wd_reg18)        /* Remote Start Address Register 0 */
  80. #define REG_RSAR1  (*wd_reg19)        /* Remote Start Address Register 1 */
  81. #define REG_RBCR0  (*wd_reg1a)        /* Remote Byte Count Register 0 */
  82. #define REG_RBCR1  (*wd_reg1b)        /* Remote Byte Count Register 1 */
  83. #define REG_RCR    (*wd_reg1c)        /* Receive Configuration Register */
  84. #define REG_TCR    (*wd_reg1d)        /* Transmit Configuration Register */
  85. #define REG_DCR    (*wd_reg1e)        /* Data Configuration Register */
  86. #define REG_IMR    (*wd_reg1f)        /* Interrupt Mask Register */
  87.  
  88. /*-- page 1, rd and wr */
  89. /*    CR    OFF_8390+0x00           Control Register    */
  90. #define REG_PAR0   (*wd_reg11)        /* Physical Address Register 0 */
  91. #define REG_PAR1   (*wd_reg12)        /*                 1 */
  92. #define REG_PAR2   (*wd_reg13)        /*                 2 */
  93. #define REG_PAR3   (*wd_reg14)        /*                 3 */
  94. #define REG_PAR4   (*wd_reg15)        /*                 4 */
  95. #define REG_PAR5   (*wd_reg16)        /*                 5 */
  96. #define REG_CURR   (*wd_reg17)        /* Current Page Register */
  97. #define REG_MAR0   (*wd_reg18)  /* Multicast Address Register 0 NA 83C690   */
  98. #define REG_MAR1   (*wd_reg19)        /*  NA for 83C690   1 */
  99. #define REG_MAR2   (*wd_reg1a)        /*  NA for 83C690   2 */
  100. #define REG_MAR3   (*wd_reg1b)        /*  NA for 83C690   3 */
  101. #define REG_MAR4   (*wd_reg1c)        /*  NA for 83C690   4 */
  102. #define REG_MAR5   (*wd_reg1d)        /*  NA for 83C690   5 */
  103. #define REG_MAR6   (*wd_reg1e)        /*  NA for 83C690   6 */
  104. #define REG_MAR7   (*wd_reg1f)        /*  NA for 83C690   7 */
  105.  
  106. #define REG_BSR    (*wd_reg01)        /*  Bus size Register */
  107. #define REG_LAAR   (*wd_reg05)        /*  LA Adress Register */
  108.  
  109. /*-------------------------------------------------------------------*/
  110. /* using the current baseio, this will enable the ram on the adapter */
  111. /* to the current rambase.                                           */
  112. /*-------------------------------------------------------------------*/
  113. void wd_enable_ram(unsigned long rambase)
  114. {
  115. unsigned char   temp;
  116. short           i;
  117.  
  118. REG_MSR = MSR_RST;
  119. for (i = 0; i < 4000; i++);
  120.  
  121. REG_MSR = ~(MSR_RST | MENB);
  122. for (i = 0; i < 4000; i++);
  123.  
  124. temp = (unsigned char)( (rambase & 0x7ffffL) >> 13);        /* encode the register bits */
  125.  
  126. REG_MSR = ((temp & ~MSR_RST) | MENB); /* load adrs and enable */
  127.  
  128. REG_LAAR = MEM16ENB | LAN16ENB | (unsigned char)(rambase  >>19);
  129. }
  130.  
  131. /*----------------------------------------------------------------*/
  132. /*  6 Byte Ethernetadresse lesen                                  */
  133. /*----------------------------------------------------------------*/
  134. void  wd_get_lan_addr(unsigned char *eth_addr)
  135. {
  136. eth_addr[0] = REG_LAN_ADDR_0;
  137. eth_addr[1] = REG_LAN_ADDR_1;
  138. eth_addr[2] = REG_LAN_ADDR_2;
  139. eth_addr[3] = REG_LAN_ADDR_3;
  140. eth_addr[4] = REG_LAN_ADDR_4;
  141. eth_addr[5] = REG_LAN_ADDR_5;
  142. }
  143.  
  144. /*----------------------------------------------------------------*/
  145. /*  6 Byte Ethernetadresse einstellen                             */
  146. /*----------------------------------------------------------------*/
  147. void  wd_set_lan_addr(unsigned char *eth_addr)
  148. {
  149. REG_LAN_ADDR_0 = eth_addr[0];
  150. REG_PAR0 = eth_addr[0];
  151. REG_LAN_ADDR_1 = eth_addr[1];
  152. REG_PAR1 = eth_addr[1];
  153. REG_LAN_ADDR_2 = eth_addr[2];
  154. REG_PAR2 = eth_addr[2];
  155. REG_LAN_ADDR_3 = eth_addr[3];
  156. REG_PAR3 = eth_addr[3];
  157. REG_LAN_ADDR_4 = eth_addr[4];
  158. REG_PAR4 = eth_addr[4];
  159. REG_LAN_ADDR_5 = eth_addr[5];
  160. REG_PAR5 = eth_addr[5];
  161. }
  162.  
  163. /*----------------------------------------------------------------*/
  164. /*  Initialisieren der Karte                                      */
  165. /*----------------------------------------------------------------*/
  166. short wd_reset(void)
  167. {
  168. long    count;
  169.  
  170. REG_CR = STP|ABR|PS0; /* soft reset and page 0 */
  171. count = 0;   /* wait for reset to finish */
  172. while ((!(REG_ISR & ISR_RST)) && (count < 20000L))
  173.  count++;
  174. if(count < 20000L)
  175.   return 1;
  176. return 0;
  177. }
  178.  
  179. /*----------------------------------------------------------------*/
  180. /*  Funktionen fuer den Betrieb                                   */
  181. /*  Globals Struktur ds enthaelt die Betriebsparameter            */
  182. /*----------------------------------------------------------------*/
  183. void wd_init_chip(void)
  184. {
  185. unsigned char    temp_cr;
  186. unsigned char    temp_rcr;
  187.  
  188. ds.tspr_hold = 0;                /* transmit page start hold */
  189. ds.pstart_hold = 0x08;                /* receive page start hold */
  190.  
  191. REG_CR = STP|ABR|PS0;    /* soft reset and page 0 */
  192.  
  193. wd_reset();
  194.  
  195. REG_DCR = 0x40 |DCR_WTS;  /* FIFO Tiefe                  */
  196.  
  197. REG_RBCR0 = 0;                /* clear remote byte count */
  198. REG_RBCR1 = 0;
  199. REG_RCR = AB|AM;                /* rcv only good pkts  */
  200. REG_TCR = LB1;                /* normal operation */
  201. REG_PSTART = ds.pstart_hold;        /* rcv ring strts 2k into RAM */
  202. ds.pstop_hold = ((ds.ramsize >> 8) & 0x00FF);        /* rcv page stop hold */
  203. REG_PSTOP = ds.pstop_hold;        /* stop at last RAM loc */
  204. REG_BNRY = ds.pstart_hold;        /* init to = PSTART */
  205. REG_ISR = 0xFF;                /* clear all int status bits */
  206. REG_IMR = 0;                        /* no interrupts yet */
  207. REG_CR = STP|ABR|PS1;                /* maintain rst | sel page 1 */
  208.  
  209. REG_PAR0 = ds.eth_addr[0];
  210. REG_MAR0 = 0;
  211. REG_PAR1 = ds.eth_addr[1];
  212. REG_MAR1 = 0;
  213. REG_PAR2 = ds.eth_addr[2];
  214. REG_MAR2 = 0;
  215. REG_PAR3 = ds.eth_addr[3];
  216. REG_MAR3 = 0;
  217. REG_PAR4 = ds.eth_addr[4];
  218. REG_MAR4 = 0;
  219. REG_PAR5 = ds.eth_addr[5];
  220. REG_MAR5 = 0;
  221. REG_MAR6 = 0;                /* there are more MAR's */
  222. REG_MAR7 = 0;                        /*   than PAR's */
  223.  
  224. temp_cr = REG_CR & ~TXP;                /* save old CR contents */
  225. REG_CR = (temp_cr & 0x3F) | PS2;        /* select page 2 */
  226. temp_rcr = REG_RCR;
  227. REG_CR = temp_cr & 0x3F;                /* select page 0 */
  228. REG_RCR = temp_rcr & ~AM;                /* disable multicast rcv */
  229. REG_CR = (temp_cr & 0x3F) | PS1;        /* select page 1 */
  230. REG_MAR4 = 0;                        /* reset multicast hash bit */
  231. REG_CR = temp_cr;                        /* restore original CR */
  232.  
  233. ds.nextpacket = ds.pstart_hold + 1;        /* internal next pkt pointer */
  234. REG_CURR = ds.nextpacket;
  235. REG_CR = STA|PS0|ABR;                /* start NIC | select page 0 */
  236. REG_TCR = 0;                        /* allow receiving pkts */
  237.  
  238. REG_IMR = PRXE|PTXE|RXEE|TXEE|OVWE; /* our interrupts */
  239.  
  240. REG_IRR = OWS;
  241. REG_REG_5 = 0x80;    /* Ethecard plus braucht das so !  */
  242. REG_REG_6 = 0x01;
  243. }
  244.  
  245.  
  246. /*----------------------------------------------------------------*/
  247. /*  aktuellen Pufferzeiger holen                                  */
  248. /*  gibt den Inhalt des CURR registers auf PAGE 1 zurueck         */
  249. /*----------------------------------------------------------------*/
  250. unsigned char wd_get_curr(void)
  251. {
  252. unsigned char              tmp_cr;
  253. unsigned char              ret_val;
  254.  
  255. tmp_cr = REG_CR;                        /* get current CR value    */
  256. REG_CR = tmp_cr | PS1;                  /* select page 1 registers */
  257. ret_val = REG_CURR;                     /* read CURR value         */
  258. REG_CR = tmp_cr;                        /* return to original value*/
  259. return ret_val;                         /* and show CURR to caller */
  260. }
  261.  
  262. short send_iack=1;                   /* Ruhezustand = sendebereit  */
  263.  
  264. /*----------------------------------------------------------------*/
  265. /*  Interrupt wird von wdasm.s aufgerufen                         */
  266. /*----------------------------------------------------------------*/
  267. void wd_interrupt(void)
  268. {
  269. unsigned char isr;
  270. unsigned short type;
  271. lan_buffer_typ    *pkt;
  272. short    recsize;
  273. int      prot;
  274. unsigned long    addr;
  275. unsigned long    limit;
  276. unsigned long    pos;
  277.  
  278. statistics.st_intr++;
  279.  
  280. isr = REG_ISR;                         /* Interrupt Status einlesen*/
  281. if(isr & (PTX | TXE))                  /* senderinterrupt          */
  282.   {
  283.   send_iack=1;
  284.   REG_ISR =PTX | TXE;                  /* Int loeschen durch beschreiben */
  285.   }
  286. if(isr & (PRX | RXE))
  287.   {
  288.   do
  289.     {
  290.     addr = (ds.rambase + (ds.nextpacket << 8));  /* Adresse des Paketes im Mem*/
  291.  
  292.     recsize = ((*(unsigned char*)(ds.vme_mem_base+addr+3)) << 8) + *((unsigned char*)(ds.vme_mem_base+addr+2)) -4;
  293.     type = ((*(unsigned char*)(ds.vme_mem_base+addr+16)) << 8) + *(unsigned char*)(ds.vme_mem_base+addr+17);
  294.  
  295.     if(recsize < 0 || recsize > 1600)
  296.       {
  297.       REG_ISR = PRX | RXE;    /* Int loeschen durch beschreiben */
  298.       statistics.st_err++;
  299.       return;
  300.       }
  301.  
  302.     limit = ds.rambase + (ds.pstop_hold << 8); /* erstes ungueltiges Byte */
  303.     pos = addr+4;                                /* Start des Datenbereiches */
  304.  
  305.     statistics.st_received++;
  306.  
  307.     for(prot = 0;prot < MAXPROTOCOLS; prot++)
  308.       {
  309.       if(protos[prot].type == type)
  310.         {
  311.              /* must have one packet free */
  312.         if((pkt = pkt_ff_get(&ff_free)) != NULL)
  313.           {
  314.           if( pos + recsize  > limit )         
  315.             {
  316.             pfcopy((unsigned char*)pkt,(unsigned char *)(ds.vme_mem_base + pos),limit-pos+1);
  317.             pfcopy((unsigned char*)( (long)pkt+(limit-pos) ),(unsigned char *)(ds.vme_mem_base + ds.rambase + (ds.pstart_hold << 8)),recsize - (limit-pos)+1);
  318.             }
  319.           else
  320.             pfcopy((unsigned char*)pkt,(unsigned char*)(ds.vme_mem_base+pos),recsize);
  321.  
  322.           if(protos[prot].handler)
  323.             { 
  324.             if(protos[prot].handler(recsize,pkt))
  325.               {
  326.               statistics.st_got++;
  327.               protos[prot].recvd++;
  328.               }
  329.             }
  330.           else
  331.             pkt_ff_put(&ff_free,pkt);
  332.           }
  333.         }
  334.       }
  335.     
  336.     ds.nextpacket = *(unsigned char*)(ds.vme_mem_base+addr+1);
  337.  
  338.     REG_BNRY = ds.nextpacket;   /* aktuelles Paket freigeben    */
  339.                                 /* Naechstes Paket geht dorthin           */
  340.     } while(ds.nextpacket != wd_get_curr());
  341.   REG_ISR = PRX | RXE;           /* Int loeschen durch beschreiben */
  342.   }
  343. if(isr & OVWE)
  344.   {
  345.   REG_CR = STP|ABR|PS0;        /* soft reset and page 0 */
  346.   REG_RBCR0 = 0;        /* clear remote byte count */
  347.   REG_RBCR1 = 0;
  348.   wd_reset();
  349.   REG_TCR = LB1;        /* keep in loopback mode */
  350.   REG_CR = STA | ABR;        /* restart it */
  351.  
  352.   ds.nextpacket = wd_get_curr();
  353.   REG_BNRY = ds.nextpacket;   /* aktuelles Paket freigeben    */
  354.  
  355.   REG_TCR = 0;            /* out of lpbk...buffer packets */
  356.   send_iack = 1;
  357.  
  358.   REG_ISR = OVWE;               /* Overwrite Int loeschen        */
  359.   }
  360. }
  361.  
  362.  
  363.  
  364. /*----------------------------------------------------------------*/
  365. /*  Paket senden                                                  */
  366. /*  Wenn nicht sendebereit : return = FALSE                       */
  367. /* to = Zeiger auf 6 Byte Ethernetadresse                         */
  368. /* len = nutzdatenlaenge                                          */
  369. /*----------------------------------------------------------------*/
  370. int wd_send(unsigned char *buffer,unsigned short len)
  371. {
  372. long    wait;
  373.  
  374. wait = 0;
  375. while(!send_iack && wait++ < 10000L);              /* warte bis sendeerlaubnis       */
  376. send_iack = 0;
  377.  
  378. if(len > 1540) len = 1540;      /* MTU fuer Ethernet              */
  379. if(len < 64) len = 64;          /* kleinstes erlaubtes Paket      */
  380.  
  381. pfcopy((unsigned char*)(ds.vme_mem_base + (long)(ds.rambase)),buffer,len+8);
  382. /*
  383. memcpy((unsigned char*)(ds.vme_mem_base + (long)(ds.rambase)),buffer,len+8);
  384. */
  385.  
  386. REG_CR = ABR|STA;               /* select page 0     */
  387. REG_TPSR = ds.tspr_hold;        /* xmit pg strt at 0 of RAM */
  388. REG_TBCR1 = (unsigned char)((len >> 8)& 0xFF); /* upper byte of count */
  389. REG_TBCR0 = (unsigned char)(len & 0xff);    /* lower byte of count */
  390. REG_CR = TXP|ABR|STA;            /* start transmission */
  391. statistics.st_sent++;
  392. return len;
  393. }
  394.  
  395. /*----------------------------------------------------------------*/
  396. /*  Ramtest                                                       */
  397. /*----------------------------------------------------------------*/
  398. long ramtest(long ram,long len)
  399. {
  400. long    i,j;
  401. long    error=0;
  402. unsigned short zykl;
  403.  
  404. for(j=0;j<5;j++)
  405.   {
  406.   zykl = j;
  407.   for(i=0;i<len;i++)
  408.     {
  409.     *(unsigned char*)(ram+i) = (zykl++ & 0xFF);
  410.     if(zykl >= 253)
  411.       zykl = 0;
  412.     }
  413.   zykl = j;
  414.   for(i=0;i<len;i++)
  415.     {
  416.     if(*(unsigned char*)(ram+i) != (zykl++ & 0xFF))
  417.       error++;
  418.     if(zykl >= 253)
  419.       zykl = 0;
  420.     } 
  421.   }
  422. return error;
  423. }
  424.  
  425. /*----------------------------------------------------------------*/
  426. /* 16 bit Ramtest                                                 */
  427. /*----------------------------------------------------------------*/
  428. long bit16_ramtest(long ram,long len)
  429. {
  430. long    i,j;
  431. long    error=0;
  432. unsigned short zykl;
  433.  
  434. for(j=0;j<5;j++)
  435.   {
  436.   zykl = j;
  437.   for(i=0;i<len/2;i++)
  438.     *(unsigned short*)(ram+i*2) = (zykl++) *3;
  439.   zykl = j;
  440.   for(i=0;i<len/2;i++)
  441.     if(*(unsigned short*)(ram+i*2) != (zykl++) *3 )
  442.       error++;
  443.   }
  444. return error;
  445. }
  446.  
  447. /*----------------------------------------------------------------*/
  448. /* 32 bit Ramtest                                                 */
  449. /*----------------------------------------------------------------*/
  450. long bit32_ramtest(long ram,long len)
  451. {
  452. long    i,j,k;
  453. long    error=0;
  454. unsigned short zykl;
  455.  
  456. for(j=0;j<5;j++)
  457.   {
  458.   zykl = j;
  459.   for(i=0;i<len/4;i++)
  460.     *(unsigned long*)(ram+i*4) = (zykl++) *143L;
  461.  
  462.   for(k=0;k<10;k++)
  463.     {
  464.     zykl = j;
  465.     for(i=0;i<len/4;i++)
  466.       if(*(unsigned long*)(ram+i*4) != (zykl++) *143L )
  467.         error++;
  468.     }
  469.   }
  470. return error;
  471. }
  472.  
  473. extern long install_vekt(void);
  474. extern long deinstall_vekt(void);
  475. extern long vekt_address;
  476. extern long vekt_level;
  477.  
  478. /*----------------------------------------------------------------*/
  479. /*  Initialisierung                                               */
  480. /*----------------------------------------------------------------*/
  481. int  wd_init(void)
  482. {
  483. long i;
  484. short erg;
  485. FILE *fil;
  486. unsigned char    addr[10];
  487. char    str[100];
  488.  
  489.             /* vorbelegen auf Werte fuer TT           */
  490. ds.vme_mem_base = 0xFE000000L;
  491. ds.rambase = 0xD0000L;
  492. ds.vekt = 0xAA;
  493. ds.level = 4;
  494.  
  495. wd_reg00 = (unsigned char*)0xFE200280L;wd_reg01 = (unsigned char*)0xFE300280L;
  496. wd_reg02 = (unsigned char*)0xFE200282L;wd_reg03 = (unsigned char*)0xFE300282L;
  497. wd_reg04 = (unsigned char*)0xFE200284L;wd_reg05 = (unsigned char*)0xFE300284L;
  498. wd_reg06 = (unsigned char*)0xFE200286L;wd_reg07 = (unsigned char*)0xFE300286L;
  499. wd_reg08 = (unsigned char*)0xFE200288L;wd_reg09 = (unsigned char*)0xFE300288L;
  500. wd_reg0a = (unsigned char*)0xFE20028aL;wd_reg0b = (unsigned char*)0xFE30028aL;
  501. wd_reg0c = (unsigned char*)0xFE20028cL;wd_reg0d = (unsigned char*)0xFE30028cL;
  502. wd_reg0e = (unsigned char*)0xFE20028eL;wd_reg0f = (unsigned char*)0xFE30028eL;
  503.  
  504. wd_reg10 = (unsigned char*)0xFE200290L;wd_reg11 = (unsigned char*)0xFE300290L;
  505. wd_reg12 = (unsigned char*)0xFE200292L;wd_reg13 = (unsigned char*)0xFE300292L;
  506. wd_reg14 = (unsigned char*)0xFE200294L;wd_reg15 = (unsigned char*)0xFE300294L;
  507. wd_reg16 = (unsigned char*)0xFE200296L;wd_reg17 = (unsigned char*)0xFE300296L;
  508. wd_reg18 = (unsigned char*)0xFE200298L;wd_reg19 = (unsigned char*)0xFE300298L;
  509. wd_reg1a = (unsigned char*)0xFE20029aL;wd_reg1b = (unsigned char*)0xFE30029aL;
  510. wd_reg1c = (unsigned char*)0xFE20029cL;wd_reg1d = (unsigned char*)0xFE30029cL;
  511. wd_reg1e = (unsigned char*)0xFE20029eL;wd_reg1f = (unsigned char*)0xFE30029eL;
  512.  
  513. if((fil = fopen("smclance.inf","r")) != NULL)
  514.   {
  515.   fscanf(fil,"%lx %lx %hx %lx %hx %hd\n",
  516.          &ds.vme_mem_base,
  517.          &ds.rambase,
  518.          &ds.vekt,
  519.          &ds.level );
  520.   fscanf(fil,"%lx %lx %lx %lx %lx %lx %lx %lx\n",&wd_reg00,&wd_reg01,&wd_reg02,&wd_reg03,&wd_reg04,&wd_reg05,&wd_reg06,&wd_reg07);
  521.   fscanf(fil,"%lx %lx %lx %lx %lx %lx %lx %lx\n",&wd_reg08,&wd_reg09,&wd_reg0a,&wd_reg0b,&wd_reg0c,&wd_reg0d,&wd_reg0e,&wd_reg0f);
  522.   fscanf(fil,"%lx %lx %lx %lx %lx %lx %lx %lx\n",&wd_reg10,&wd_reg11,&wd_reg12,&wd_reg13,&wd_reg14,&wd_reg15,&wd_reg16,&wd_reg17);
  523.   fscanf(fil,"%lx %lx %lx %lx %lx %lx %lx %lx\n",&wd_reg18,&wd_reg19,&wd_reg1a,&wd_reg1b,&wd_reg1c,&wd_reg1d,&wd_reg1e,&wd_reg1f);
  524.   fclose(fil);
  525.   }
  526. else
  527.   {
  528.   sprintf(str,"kann smclance.inf nicht oeffnen -> nehme Standartwerte\n");  
  529.   debug_str(str);
  530.   }
  531.  
  532. debug_str("");
  533. sprintf(str,"vme MEM Base   : %lx",ds.vme_mem_base);debug_str(str);
  534. sprintf(str,"PC RAM address : %lx",ds.rambase);debug_str(str);
  535. sprintf(str,"INT Vektor     : %hx",ds.vekt);debug_str(str);
  536. sprintf(str,"INT Vektor addr: %hx",ds.vekt << 2);debug_str(str);
  537. sprintf(str,"INT Level      : %hd",ds.level);debug_str(str);
  538. sprintf(str,"WD Register    : %08lX, %08lX, %08lX, %08lX ... %08lX, %08lX",wd_reg00,wd_reg01,wd_reg02,wd_reg03,wd_reg1e,wd_reg1f);debug_str(str);
  539.  
  540.  
  541. vekt_address = (long)ds.vekt << 2;  /* Adresse des Vektors  */
  542. vekt_level = (long)ds.level;        /* Interruptlevel       */
  543. Supexec(install_vekt);
  544.  
  545. ds.ramsize = 0x4000L;  /* 16 K */
  546.  
  547. wd_get_lan_addr(ds.eth_addr);   /* wird bei wd_init gesetzt in Physical adress */
  548. wd_get_lan_addr(addr);
  549. sprintf(str,"Adresse        : %02X %02X %02X %02X %02X %02X\n",addr[0],addr[1],addr[2],addr[3],addr[4],addr[5]);debug_str(str);
  550.  
  551. wd_enable_ram(ds.rambase); 
  552.  
  553. erg = wd_reset();
  554. if(!erg)
  555.   {
  556.   debug_str("Fehler beim WD Reset");
  557.   return -1;
  558.   }
  559.  
  560. wd_init_chip();
  561. debug_str("----------------------------");
  562.  
  563.                 /* einige werte schreiben und lesen, um Interface zu aktivieren */
  564. erg =  *(unsigned char*)(ds.vme_mem_base + ds.rambase);
  565. *(unsigned char*)(ds.vme_mem_base + ds.rambase) = erg;
  566. erg =  *(unsigned short*)(ds.vme_mem_base + ds.rambase);
  567. *(unsigned short*)(ds.vme_mem_base + ds.rambase) = erg;
  568.  
  569. debug_str("starte Ramtest ...");
  570. i = ramtest(ds.rambase+ds.vme_mem_base,ds.ramsize);
  571. if(i)
  572.   {
  573.   sprintf(str,"           %lx Fehler",i);debug_str(str);
  574. /*  return -1; */
  575.   }
  576. else
  577.   debug_str(" OK");
  578.  
  579. debug_str("starte 16 Bit Ramtest ...");
  580. i = bit16_ramtest(ds.rambase+ds.vme_mem_base,ds.ramsize);
  581. if(i)
  582.   {
  583.   sprintf(str,"           %lx Fehler",i);debug_str(str);
  584. /*  return -1; */
  585.   }
  586. else
  587.   debug_str(" OK");
  588.  
  589. debug_str("starte long Ramtest (gründlich) ...");
  590. i = bit32_ramtest(ds.rambase+ds.vme_mem_base,ds.ramsize);
  591. if(i)
  592.   {
  593.   sprintf(str,"           %lx Fehler",i);debug_str(str);
  594. /*  return -1; */
  595.   }
  596. else
  597.   debug_str(" OK");
  598.  
  599. for(i=0;i<ds.ramsize;i++)
  600.   *(unsigned char*)(ds.vme_mem_base + ds.rambase +i) = 0;
  601. return 0;
  602. }
  603.  
  604. /*----------------------------------------------------------------*/
  605. /*  Initialisierung                                               */
  606. /*----------------------------------------------------------------*/
  607. void  wd_deinit(void)
  608. {
  609. Supexec(deinstall_vekt);
  610. }
  611.